context.valueCtx.Err (method, view implemented interface methods)

100 uses

	context (current package)
		context.go#L115: 	Err() error
		context.go#L289: 	err := c.Err()
		context.go#L486: 		child.cancel(false, parent.Err(), Cause(parent))
		context.go#L511: 			child.cancel(false, parent.Err(), Cause(parent))
		context.go#L525: 			child.cancel(false, parent.Err(), Cause(parent))

	crypto/tls
		conn.go#L1544: 				ret = ctx.Err()
		quic.go#L520: 	if c.quic.ctx.Err() != nil {

	github.com/cenkalti/backoff/v4
		retry.go#L99: 			if cerr := ctx.Err(); cerr != nil {
		retry.go#L114: 			return res, ctx.Err()

	github.com/coder/websocket
		conn.go#L255: 		return fmt.Errorf("failed to wait for pong: %w", ctx.Err())
		conn.go#L291: 		return fmt.Errorf("failed to acquire lock: %w", ctx.Err())
		read.go#L255: 	if *err != nil && ctx.Err() != nil {
		read.go#L256: 		*err = ctx.Err()
		write.go#L300: 			if ctx.Err() != nil {
		write.go#L301: 				err = ctx.Err()

	github.com/gotd/td/mtproto
		ack.go#L33: 			return errors.Wrap(ctx.Err(), "acl")
		pfs.go#L23: 		return ctx.Err()
		pfs.go#L47: 			return ctx.Err()
		ping.go#L34: 		return ctx.Err()
		ping.go#L78: 		return ctx.Err()
		ping.go#L107: 			return errors.Wrap(ctx.Err(), "ping loop")
		read.go#L95: 			return ctx.Err()
		read.go#L178: 				return ctx.Err()
		read.go#L196: 				return errors.Wrap(ctx.Err(), "read loop")
		salt.go#L54: 		return ctx.Err()
		salt.go#L71: 			return ctx.Err()

	github.com/gotd/td/pool
		pool.go#L186: 			return nil, ctx.Err()
		pool.go#L188: 			return nil, errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L223: 		err = ctx.Err()
		pool.go#L225: 		err = errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L258: 		if err != nil && errRetryableOnNewConn(err) && ctx.Err() == nil {

	github.com/gotd/td/rpc
		engine.go#L141: 	if err != nil && !errors.Is(err, retryCtx.Err()) {
		engine.go#L155: 			return ctx.Err()
		engine.go#L170: 			return ctx.Err()
		engine.go#L174: 		return ctx.Err()
		engine.go#L186: 		return errors.Wrap(e.reqCtx.Err(), "engine forcibly closed")
		engine.go#L220: 				return ctx.Err()

	github.com/gotd/td/telegram
		bot.go#L14: 	return ctx.Err()
		builder.go#L129: 					return ctx.Err()
		cdn.go#L175: 		return fetchedCDNKeys{}, ctx.Err()
		cdn.go#L271: 		if err := ctx.Err(); err != nil {
		connect.go#L40: 					return ctx.Err()
		connect.go#L81: 			return ctx.Err()
		connect.go#L162: 			return errors.Wrap(c.ctx.Err(), "client already closed")
		connect.go#L211: 			return ctx.Err()
		connect.go#L213: 			return c.ctx.Err()
		connect.go#L219: 			return ctx.Err()
		invoke.go#L113: 			return errors.Wrap(ctx.Err(), "wait for reconnect")
		invoke.go#L116: 			return errors.Wrap(c.ctx.Err(), "client closed")
		migrate_to_dc.go#L17: 		return ctx.Err()
		migrate_to_dc.go#L24: 		return ctx.Err()
		migrate_to_dc.go#L36: 		return ctx.Err()
		migrate_to_dc.go#L70: 		return ctx.Err()
		pool.go#L29: 		return nil, errors.Wrap(c.ctx.Err(), "client already closed")

	github.com/gotd/td/telegram/auth/qrlogin
		qrlogin.go#L166: 			return nil, ctx.Err()
		qrlogin.go#L182: 			return nil, ctx.Err()

	github.com/gotd/td/telegram/dcs
		plain.go#L191: 			return nil, ctx.Err()

	github.com/gotd/td/telegram/downloader
		cdn_state_machine.go#L147: 		if err := ctx.Err(); err != nil {
		cdn_state_machine.go#L307: 		if err := ctx.Err(); err != nil {
		cdn_verify.go#L148: 		if err := ctx.Err(); err != nil {
		parallel.go#L44: 						return ctx.Err()
		parallel.go#L64: 						return ctx.Err()
		retry.go#L38: 	if ctx.Err() != nil {
		retry.go#L59: 		if err := ctx.Err(); err != nil {
		retry.go#L67: 				if ctxErr := ctx.Err(); ctxErr != nil {
		sink.go#L15: 				return ctx.Err()
		sink.go#L35: 				return ctx.Err()
		stream.go#L39: 				return ctx.Err()

	github.com/gotd/td/telegram/internal/manager
		conn.go#L164: 		if err != nil && ctx.Err() == nil {
		conn.go#L189: 		return ctx.Err()

	github.com/gotd/td/tgerr
		flood_wait.go#L72: 			return false, ctx.Err()

	github.com/refraction-networking/utls
		conn.go#L1558: 				interruptRes <- handshakeCtx.Err()
		u_conn.go#L354: 				interruptRes <- handshakeCtx.Err()

	golang.org/x/net/internal/socks
		client.go#L43: 				errCh <- ctx.Err()

	golang.org/x/net/proxy
		dial.go#L44: 		if conn != nil && ctx.Err() != nil {
		dial.go#L50: 		err = ctx.Err()

	net
		cgo_unix.go#L76: 		return zero, newDNSError(mapErr(ctx.Err()), lookupName, "")
		dial.go#L735: 			return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
		fd_unix.go#L53: 			return nil, mapErr(ctx.Err())
		fd_unix.go#L103: 				ret = mapErr(ctx.Err())
		fd_unix.go#L122: 				return nil, mapErr(ctx.Err())
		lookup.go#L358: 		err := newDNSError(mapErr(ctx.Err()), host, "")
		net.go#L817: 		return ctx.Err()

	net/http
		h2_bundle.go#L1031: 	return call.ctx.Err() != nil
		h2_bundle.go#L7920: 					err = req.Context().Err()
		h2_bundle.go#L8504: 		return ctx.Err()
		h2_bundle.go#L8631: 			return ctx.Err()
		h2_bundle.go#L8704: 			err := ctx.Err()
		h2_bundle.go#L8753: 			return ctx.Err()
		h2_bundle.go#L8765: 		return ctx.Err()
		h2_bundle.go#L8822: 				err = ctx.Err()
		h2_bundle.go#L8868: 			return ctx.Err()
		h2_bundle.go#L8887: 		return ctx.Err()
		h2_bundle.go#L9303: 			return 0, ctx.Err()
		h2_bundle.go#L10312: 		return ctx.Err()
		server.go#L3181: 			return ctx.Err()
		server.go#L3856: 		switch err := ctx.Err(); err {
		socks_bundle.go#L49: 				errCh <- ctx.Err()
		transport.go#L1914: 			return nil, connectCtx.Err()
		transport.go#L2809: 		return ctx.Err()